Isometric Game Programming with DirectX 7.0/Isometric Game Programming.iso/source/chapter8/isohex8_1/isohex8_1.cpp

C/C++ Source or Header | 2000-05-25 | 12.3 KB | 500 lines

/*****************************************************************************
IsoHex8_1.cpp
Ernest S. Pazera
24MAY2000
Start a WIN32 Application Workspace, add in this file
Needs ddraw.lib and dxguid.lib
Needs GDICanvas.h/cpp
Needs DDFuncs.h/cpp
Needs winmm.lib and mmsystem.h
*****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
//INCLUDES
//////////////////////////////////////////////////////////////////////////////
#define WIN32_LEAN_AND_MEAN

#include <windows.h>
#include "GDICanvas.h"
#include "ddraw.h"
#include "DDFuncs.h"
#include "mmsystem.h"

//////////////////////////////////////////////////////////////////////////////
//DEFINES
//////////////////////////////////////////////////////////////////////////////
//name for our window class
#define WINDOWCLASS "ISOHEX8"
//title of the application
#define WINDOWTITLE "IsoHex 8-1"

//////////////////////////////////////////////////////////////////////////////
//PROTOTYPES
//////////////////////////////////////////////////////////////////////////////
bool Prog_Init();//game data initalizer
void Prog_Loop();//main game loop
void Prog_Done();//game clean up

//enumeration functions
HRESULT WINAPI EnumModesCallbackCount(LPDDSURFACEDESC2 lpDDSurfaceDesc, LPVOID lpContext);
HRESULT WINAPI EnumModesCallbackList(LPDDSURFACEDESC2 lpDDSurfaceDesc,LPVOID lpContext);

//////////////////////////////////////////////////////////////////////////////
//GLOBALS
//////////////////////////////////////////////////////////////////////////////
HINSTANCE hInstMain=NULL;//main application handle
HWND hWndMain=NULL;//handle to our main window
//IDirectDraw7 Pointer
LPDIRECTDRAW7 lpdd=NULL;
//display mode structure
struct DisplayMode
{
    DWORD dwWidth;
    DWORD dwHeight;
    DWORD dwBPP;
};
//display mode enumeration variables
DWORD dwDisplayModeCount=0;
DisplayMode* DisplayModeList=NULL;

//gdicanvas
CGDICanvas gdicBall;

//surfaces
LPDIRECTDRAWSURFACE7 lpddsPrime=NULL;
LPDIRECTDRAWSURFACE7 lpddsBack=NULL;
LPDIRECTDRAWSURFACE7 lpddsBall=NULL;

//clipper
LPDIRECTDRAWCLIPPER lpddclip=NULL;

//size of the display
DWORD dwDisplayWidth=0;
DWORD dwDisplayHeight=0;

//position of the ball
POINT ptBallPosition[2];
POINT ptLastPosition[2][2];
//velocity of the ball
POINT ptBallVelocity[2];

//paused mode
bool bPaused=false;

//////////////////////////////////////////////////////////////////////////////
//WINDOWPROC
//////////////////////////////////////////////////////////////////////////////
LRESULT CALLBACK TheWindowProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
{
    //which message did we get?
    switch(uMsg)
    {
    case WM_ACTIVATEAPP:
        {
            if(wParam)
            {
                if(bPaused)
                {
                    //being activated
                    bPaused=false;

                    //restore all surfaces
                    lpdd->RestoreAllSurfaces();

                    //clear out back buffer
                    DDBLTFX ddbltfx;
                    DDBLTFX_ColorFill(&ddbltfx,0);
                    lpddsBack->Blt(NULL,NULL,NULL,DDBLT_WAIT | DDBLT_COLORFILL,&ddbltfx);

                    //reload ball images
                    LPDDS_ReloadFromFile(lpddsBall,"IsoHex6_4.bmp");
                }
            }
            else
            {
                //being deactivated
                bPaused=true;
            }
        }break;
    case WM_KEYDOWN:
        {
            //check for escape key
            if(wParam==VK_ESCAPE)
            {
                DestroyWindow(hWndMain);
            }

            return(0);//handled message
        }break;
    case WM_DESTROY://the window is being destroyed
        {

            //tell the application we are quitting
            PostQuitMessage(0);

            //handled message, so return 0
            return(0);

        }break;
    case WM_PAINT://the window needs repainting
        {
            //a variable needed for painting information
            PAINTSTRUCT ps;

            //start painting
            HDC hdc=BeginPaint(hwnd,&ps);

            /////////////////////////////
            //painting code would go here
            /////////////////////////////

            //end painting
            EndPaint(hwnd,&ps);

            //handled message, so return 0
            return(0);
        }break;
    }

    //pass along any other message to default message handler
    return(DefWindowProc(hwnd,uMsg,wParam,lParam));
}


//////////////////////////////////////////////////////////////////////////////
//WINMAIN
//////////////////////////////////////////////////////////////////////////////
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nShowCmd)
{
    //assign instance to global variable
    hInstMain=hInstance;

    //create window class
    WNDCLASSEX wcx;

    //set the size of the structure
    wcx.cbSize=sizeof(WNDCLASSEX);

    //class style
    wcx.style=CS_OWNDC | CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;

    //window procedure
    wcx.lpfnWndProc=TheWindowProc;

    //class extra
    wcx.cbClsExtra=0;

    //window extra
    wcx.cbWndExtra=0;

    //application handle
    wcx.hInstance=hInstMain;

    //icon
    wcx.hIcon=LoadIcon(NULL,IDI_APPLICATION);

    //cursor
    wcx.hCursor=LoadCursor(NULL,IDC_ARROW);

    //background color
    wcx.hbrBackground=(HBRUSH)GetStockObject(BLACK_BRUSH);

    //menu
    wcx.lpszMenuName=NULL;

    //class name
    wcx.lpszClassName=WINDOWCLASS;

    //small icon
    wcx.hIconSm=NULL;

    //register the window class, return 0 if not successful
    if(!RegisterClassEx(&wcx)) return(0);

    //create main window
    hWndMain=CreateWindowEx(0,WINDOWCLASS,WINDOWTITLE, WS_POPUP | WS_VISIBLE,0,0,320,240,NULL,NULL,hInstMain,NULL);

    //error check
    if(!hWndMain) return(0);

    //if program initialization failed, then return with 0
    if(!Prog_Init()) return(0);

    //message structure
    MSG msg;

    //message pump
    for(;;)
    {
        //look for a message
        if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
        {
            //there is a message

            //check that we arent quitting
            if(msg.message==WM_QUIT) break;

            //translate message
            TranslateMessage(&msg);

            //dispatch message
            DispatchMessage(&msg);
        }

        //run main game loop
        Prog_Loop();
    }

    //clean up program data
    Prog_Done();

    //return the wparam from the WM_QUIT message
    return(msg.wParam);
}

//////////////////////////////////////////////////////////////////////////////
//INITIALIZATION
//////////////////////////////////////////////////////////////////////////////
bool Prog_Init()
{
    lpdd=LPDD_Create(hWndMain,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT);

    //enumerate the displaymodes
    dwDisplayModeCount=0;

    lpdd->EnumDisplayModes(0,NULL,NULL,EnumModesCallbackCount);

    DisplayModeList=new DisplayMode[dwDisplayModeCount];
    dwDisplayModeCount=0;

    lpdd->EnumDisplayModes(0,NULL,NULL,EnumModesCallbackList);

    //pick a display mode
    DisplayMode TestMode;
    TestMode.dwWidth=0;
    TestMode.dwHeight=0;
    TestMode.dwBPP=0;
    DWORD index;
    bool found=false;

    for(index=0;(index<dwDisplayModeCount);index++)
    {
        if(DisplayModeList[index].dwBPP==16)
        {
            if(DisplayModeList[index].dwWidth>TestMode.dwWidth)
            {
                TestMode.dwWidth=DisplayModeList[index].dwWidth;
                TestMode.dwHeight=DisplayModeList[index].dwHeight;
                TestMode.dwBPP=DisplayModeList[index].dwBPP;
                found=true;
            }
        }
    }

    if(!found)
    {
        return(false);
    }

    //set the display mode
    lpdd->SetDisplayMode(TestMode.dwWidth,TestMode.dwHeight,TestMode.dwBPP,0,0);
    //keep display width and height in global variables
    dwDisplayWidth=TestMode.dwWidth;
    dwDisplayHeight=TestMode.dwHeight;

    //create the primary surface with a single back buffer
    lpddsPrime=LPDDS_CreatePrimary(lpdd,1);

    //retrieve back buffer
    lpddsBack=LPDDS_GetSecondary(lpddsPrime);

    //do an initial clearing out of the back buffer
    DDBLTFX ddbltfx;
    DDBLTFX_ColorFill(&ddbltfx,0);

    //do a color fill
    lpddsBack->Blt(NULL,NULL,NULL,DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);

    //create the region
    HRGN hrgn=CreateRectRgn(0,0,dwDisplayWidth,dwDisplayHeight);

    //set up clipper
    lpddclip=LPDDCLIP_Create(lpdd,hrgn);

    //delete region
    DeleteObject(hrgn);

    //attach clipper
    lpddsBack->SetClipper(lpddclip);

    //load in the ball image
    gdicBall.Load(NULL,"IsoHex8_1.bmp");

    //create an offscreen surface to contain the ball
    lpddsBall=LPDDS_LoadFromFile(lpdd,"IsoHex8_1.bmp");

    //create a black color key
    LPDDS_SetSrcColorKey(lpddsBall,0);

    //initialize ball position and velocity
    ptBallPosition[0].x=0;
    ptBallPosition[0].y=0;
    ptLastPosition[0][0].x=0;
    ptLastPosition[0][0].y=0;
    ptLastPosition[0][1].x=0;
    ptLastPosition[0][1].y=0;
    ptBallPosition[1].x=0;
    ptBallPosition[1].y=0;
    ptLastPosition[1][0].x=0;
    ptLastPosition[1][0].y=0;
    ptLastPosition[1][1].x=0;
    ptLastPosition[1][1].y=0;

    ptBallVelocity[0].x=(rand()&7)+1;
    ptBallVelocity[0].y=(rand()&7)+1;
    ptBallVelocity[1].x=(rand()&7)+1;
    ptBallVelocity[1].y=(rand()&7)+1;


    return(true);//return success
}

//////////////////////////////////////////////////////////////////////////////
//CLEANUP
//////////////////////////////////////////////////////////////////////////////
void Prog_Done()
{
    //clean up clipper
    LPDDCLIP_Release(&lpddclip);

    //clean up ball surface
    LPDDS_Release(&lpddsBall);

    //clean up primary surface(this will clean up the back buffer, also)
    LPDDS_Release(&lpddsPrime);

    //clean up the dd pointer
    LPDD_Release(&lpdd);

    //clean up gdicanvas
    gdicBall.Destroy();

    //get rid of enumeration stuff
    delete [] DisplayModeList;
}

//////////////////////////////////////////////////////////////////////////////
//MAIN GAME LOOP
//////////////////////////////////////////////////////////////////////////////
void Prog_Loop()
{
    //if paused, return without doing anything
    if(bPaused) return;

    int index;

    for(index=0;index<2;index++)
    {

    //set up rectangle for filling
    RECT rcFill;
    SetRect(&rcFill,ptLastPosition[index][0].x,ptLastPosition[index][0].y,ptLastPosition[index][0].x+gdicBall.GetWidth(),ptLastPosition[index][0].y+gdicBall.GetHeight());

    //set up a ddbltfx
    DDBLTFX ddbltfx;
    DDBLTFX_ColorFill(&ddbltfx,0);

    //blt the color fill to the back buffer
    lpddsBack->Blt(&rcFill,NULL,NULL,DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
    }

    for(index=0;index<2;index++)
    {
    //set up source and destination rects for blitting the ball
    RECT rcSrc;
    RECT rcDst;

    SetRect(&rcSrc,0,0,gdicBall.GetWidth(),gdicBall.GetHeight());
    CopyRect(&rcDst,&rcSrc);
    OffsetRect(&rcDst,ptBallPosition[index].x,ptBallPosition[index].y);

    //blit the ball
    lpddsBack->Blt(&rcDst,lpddsBall,&rcSrc,DDBLT_WAIT | DDBLT_KEYSRC, NULL);

    //copy current position of ball to old position
    ptLastPosition[index][0]=ptLastPosition[index][1];
    ptLastPosition[index][1]=ptBallPosition[index];

    //move the ball
    ptBallPosition[index].x+=ptBallVelocity[index].x;
    ptBallPosition[index].y+=ptBallVelocity[index].y;

    //bounds checking
    //left side
    if(ptBallPosition[index].x<=0)
    {
        //change direction
        ptBallVelocity[index].x=abs(ptBallVelocity[index].x);
        //play sound
        PlaySound("bounce.wav",NULL,SND_FILENAME | SND_ASYNC);
    }
    //top side
    if(ptBallPosition[index].y<=0)
    {
        //change direction
        ptBallVelocity[index].y=abs(ptBallVelocity[index].y);
        //play sound
        PlaySound("bounce.wav",NULL,SND_FILENAME | SND_ASYNC);
    }
    //right side
    if(ptBallPosition[index].x>=(int)dwDisplayWidth-gdicBall.GetWidth())
    {
        //change direction
        ptBallVelocity[index].x=-abs(ptBallVelocity[index].x);
        //play sound
        PlaySound("bounce.wav",NULL,SND_FILENAME | SND_ASYNC);
    }
    //bottom side
    if(ptBallPosition[index].y>=(int)dwDisplayHeight-gdicBall.GetHeight())
    {
        //change direction
        ptBallVelocity[index].y=-abs(ptBallVelocity[index].y);
        //play sound
        PlaySound("bounce.wav",NULL,SND_FILENAME | SND_ASYNC);
    }
    }
    //flip surfaces
    lpddsPrime->Flip(NULL,DDFLIP_WAIT);
}

//enumeration-count
HRESULT WINAPI EnumModesCallbackCount(
  LPDDSURFACEDESC2 lpDDSurfaceDesc,
  LPVOID lpContext
)
{
    //increment the count variable
    dwDisplayModeCount++;

    //continue the enumeration
    return(DDENUMRET_OK);
}

//enumeration-list
HRESULT WINAPI EnumModesCallbackList(
  LPDDSURFACEDESC2 lpDDSurfaceDesc,
  LPVOID lpContext
)
{
    //copy applicable information to the list
    DisplayModeList[dwDisplayModeCount].dwWidth=lpDDSurfaceDesc->dwWidth;
    DisplayModeList[dwDisplayModeCount].dwHeight=lpDDSurfaceDesc->dwHeight;
    DisplayModeList[dwDisplayModeCount].dwBPP=lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount;

    //increment the count variable
    dwDisplayModeCount++;

    //continue the enumeration
    return(DDENUMRET_OK);
}